package test.thread ;

/**
 * 测试sleep方法是否会释放对象锁
 * @author 80002165 @date 2017年4月27日 上午9:12:29
 */
public class JudgeSleepReleaseLock {
    static class ThreadA extends Thread {
        Object lock ;
        
        public ThreadA(Object lock) {
            super("线程A") ;
            this.lock = lock ;
        }
        
        @Override
        public void run() {
            synchronized (this.lock) {
                int i = 1 ;
                for(;i<20;i++) {
                    System.out.println("我得到了lock锁" + i++) ;
                    if (i == 10) {
                        System.out.println("好累，我要休息一下！") ;
                        try {
                            sleep(10000) ;
                        } catch (InterruptedException e) {
                            e.printStackTrace() ;
                        }
                    }
                }
            }
        }
    }
    
    static class ThreadB extends Thread {
        Object lock ;
        
        public ThreadB(Object lock) {
            super("线程B") ;
            this.lock = lock ;
        }
        
        @Override
        public void run() {
            System.out.println("我是线程B，我是在等待，一个锁对象！") ;
            synchronized(this.lock){
                System.out.println("千年等一会，噢噢噢噢，我等到了锁！") ;
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        System.out.println("呜呜呜，测试开始啦!") ;
        Object lock = new Object() ;
        ThreadA a = new ThreadA(lock) ;
        ThreadB b = new ThreadB(lock) ;
        
        a.start(); 
        
        //确保A线程先获得锁对象
        Thread.sleep(500);
        
        b.start();
    }
}
/*
 * 多次测试从打印的结果看出来，sleep并不会释放对象的锁，此时线程依然持有其锁对象，在该锁对象上阻塞的其他线程依然阻塞等待着该锁对象的释放 
 */
 
/* print:
呜呜呜，测试开始啦!
我得到了lock锁1
我得到了lock锁3
我得到了lock锁5
我得到了lock锁7
我得到了lock锁9
好累，我要休息一下！
我是线程B，我是在等待，一个锁对象！
我得到了lock锁11
我得到了lock锁13
我得到了lock锁15
我得到了lock锁17
我得到了lock锁19
千年等一会，噢噢噢噢，我等到了锁！
 * */
